SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>External variable</title>

</head>

<span id="openzim-page-title" class="mw-page-title-main"><span class="mw-page-title-main">External variable</span></span>

</h1>

</header>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hatnote{font-style:italic}.mw-parser-output div.hatnote{padding-left:1.6em;margin-bottom:0.5em}.mw-parser-output .hatnote i{font-style:normal}.mw-parser-output .hatnote+link+.hatnote{margin-top:-0.5em}@media print{body.ns-0 .mw-parser-output .hatnote{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div role="note" class="hatnote navigation-not-searchable">"Extern" redirects here. For the job title, see <a href="Externship" title="Externship">externship</a>.</div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .ambox{border:1px solid #a2a9b1;border-left:10px solid #36c;background-color:#fbfbfb;box-sizing:border-box}.mw-parser-output .ambox+link+.ambox,.mw-parser-output .ambox+link+style+.ambox,.mw-parser-output .ambox+link+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+style+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+link+.ambox{margin-top:-1px}html body.mediawiki .mw-parser-output .ambox.mbox-small-left{margin:4px 1em 4px 0;overflow:hidden;width:238px;border-collapse:collapse;font-size:88%;line-height:1.25em}.mw-parser-output .ambox-speedy{border-left:10px solid #b32424;background-color:#fee7e6}.mw-parser-output .ambox-delete{border-left:10px solid #b32424}.mw-parser-output .ambox-content{border-left:10px solid #f28500}.mw-parser-output .ambox-style{border-left:10px solid #fc3}.mw-parser-output .ambox-move{border-left:10px solid #9932cc}.mw-parser-output .ambox-protection{border-left:10px solid #a2a9b1}.mw-parser-output .ambox .mbox-text{border:none;padding:0.25em 0.5em;width:100%}.mw-parser-output .ambox .mbox-image{border:none;padding:2px 0 2px 0.5em;text-align:center}.mw-parser-output .ambox .mbox-imageright{border:none;padding:2px 0.5em 2px 0;text-align:center}.mw-parser-output .ambox .mbox-empty-cell{border:none;padding:0;width:1px}.mw-parser-output .ambox .mbox-image-div{width:52px}@media(min-width:720px){.mw-parser-output .ambox{margin:0 10%}}@media print{body.ns-0 .mw-parser-output .ambox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style>

<p>In the <a href="C_programming_language" class="mw-redirect" title="C programming language">C programming language</a>, and its predecessor <a href="B_programming_language" class="mw-redirect" title="B programming language">B</a>, an <b>external variable</b> is a variable defined outside any function block. On the other hand, a local (automatic) variable is a variable defined inside a function block.

</p>

/* start https://en.wikipedia.org/ */

.mw-parser-output .templatequote{overflow:hidden;margin:1em 0;padding:0 32px}.mw-parser-output .templatequotecite{line-height:1.5em;text-align:left;margin-top:0}@media(min-width:500px){.mw-parser-output .templatequotecite{padding-left:1.6em}}

/* end https://en.wikipedia.org/ */

</style><blockquote class="templatequote"><p>As an alternative to automatic variables, it is possible to define variables that are external to all functions, that is, variables that can be accessed by name by any function. (This mechanism is rather like <a href="Fortran" title="Fortran">Fortran</a> COMMON or <a href="Pascal_(programming_language)" title="Pascal (programming language)">Pascal</a> variables declared in the outermost block.) Because external variables are globally accessible, they can be used instead of argument lists to communicate data between functions. Furthermore, because external variables remain in existence permanently, rather than appearing and disappearing as functions are called and exited, they retain their values even after the functions that set them have returned.</p></blockquote><div class="templatequotecite"><p style="display: inline; padding-left: 2.3em;">— <i><a href="The_C_Programming_Language" title="The C Programming Language">The C Programming Language</a></i></p></div>

<div class="mw-heading mw-heading2"><h2 id="Definition,_declaration_and_the_extern_keyword">Definition, declaration and the <code>extern</code> keyword</h2></div>

<div class="mw-heading mw-heading3"><h3 id="extrn">extrn</h3></div>

<p>In B, all variables must be declared, as one of auto, extrn, or implicitly as function arguments.<sup id="cite_ref-b_1-0" class="reference"><a href="#cite_note-b-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup> An external variable is defined outside functions, has a lifetime of the whole program execution, and introduced to function by the mean of <code>extrn</code> declaration.

</p><p>Using the following code in the tutorial as an example: <sup id="cite_ref-b_1-1" class="reference"><a href="#cite_note-b-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup>

</p>

<span class="w"> </span><span class="n">extrn</span><span class="w"> </span><span class="n">a</span><span class="p">,</span><span class="w"> </span><span class="n">b</span><span class="p">,</span><span class="w"> </span><span class="n">c</span><span class="p">;</span>

<span class="w"> </span><span class="n">putchar</span><span class="p">(</span><span class="n">a</span><span class="p">);</span><span class="w"> </span><span class="n">putchar</span><span class="p">(</span><span class="n">b</span><span class="p">);</span><span class="w"> </span><span class="n">putchar</span><span class="p">(</span><span class="n">c</span><span class="p">);</span><span class="w"> </span><span class="n">putchar</span><span class="p">(</span><span class="err">'</span><span class="o">!*</span><span class="n">n</span><span class="err">'</span><span class="p">);</span>

</pre></div>

<p><code>a</code>, <code>b</code>, <code>c</code> are all external variables of the program defined outside functions, and introduced to the <code>main</code> function by <code>extrn</code> declarations.

</p>

<div class="mw-heading mw-heading3"><h3 id="extern">extern</h3></div>

<p>To understand how external variables relate to the <code>extern</code> keyword, it is necessary to know the difference between defining and declaring a variable. When a variable is <i>defined</i>, the compiler allocates memory for that variable and possibly also initializes its contents to some value. When a variable is <i>declared</i>, the compiler requires that the variable be defined elsewhere. The declaration informs the compiler that a variable by that name and type exists, but the compiler does not need to allocate memory for it since it is allocated elsewhere.

The <code>extern</code> keyword means "declare without defining". In other words, it is a way to explicitly declare a variable, or to force a declaration without a definition. It is also possible to explicitly define a variable, i.e. to force a definition. It is done by assigning an initialization value to a variable. If neither the <code>extern</code> keyword nor an initialization value are present, the statement can be either a declaration or a definition. It is up to the compiler to analyse the modules of the program and decide.

</p><p>A variable must be defined exactly once in one of the modules of the program. If there is no definition or more than one, an error is produced, possibly in the linking stage. A variable may be declared many times, as long as the declarations are consistent with each other and with the definition (something which <a href="Header_files" class="mw-redirect" title="Header files">header files</a> facilitate greatly). It may be declared in many modules, including the module where it was defined, and even many times in the same module. But it is usually pointless to declare it more than once in a module.

</p><p>An external variable may also be declared inside a function. In this case the <code>extern</code> keyword must be used, otherwise the compiler will consider it a definition of a local (<a href="Automatic_variable" title="Automatic variable">automatic</a>) variable, which has a different scope, lifetime and initial value. This declaration will only be visible inside the function instead of throughout the function's module.

</p><p>The <code>extern</code> keyword applied to a function prototype does absolutely nothing (the <code>extern</code> keyword applied to a function definition is, of course, non-sensical). A function prototype is always a declaration and never a definition. Also, in standard C, a function is always external, but some compiler extensions allow a function to be defined inside a function.

</p>

<p>An external variable must be defined, exactly once, outside of any function; this sets aside storage for it. The variable must also be declared in each function that wants to access it; this states the type of the variable. The declaration may be an explicit <code>extern</code> statement or may be implicit from context.

...

You should note that we are using the words definition and declaration carefully when we refer to external variables in this section. <i>Definition</i> refers to the place where the variable is created or assigned storage; <i>declaration</i> refers to places where the nature of the variable is stated but no storage is allocated.

</p>

</blockquote><div class="templatequotecite"><p style="display: inline; padding-left: 2.3em;">— <i><a href="The_C_Programming_Language" title="The C Programming Language">The C Programming Language</a></i></p></div>

<div class="mw-heading mw-heading2"><h2 id="Scope,_lifetime_and_the_static_keyword">Scope, lifetime and the <code>static</code> keyword</h2></div>

<div role="note" class="hatnote navigation-not-searchable">See also: <a href="Static_(keyword)" title="Static (keyword)">Static (keyword)</a></div>

<p>An external variable can be accessed by all the functions in all the modules of a program. It is a <a href="Global_variable" title="Global variable">global variable</a>. For a function to be able to use the variable, a declaration or the definition of the external variable must lie before the function definition in the source code. Or there must be a declaration of the variable, with the keyword <code>extern</code>, inside the function.

</p><p>The <a href="Static_(keyword)" title="Static (keyword)"><code>static</code> keyword</a> (<code>static</code> and <code>extern</code> are mutually exclusive), applied to the definition of an external variable, changes this a bit: the variable can only be accessed by the functions in the same module where it was defined. But it is possible for a function in the same module to pass a reference (pointer) of the variable to another function in another module. In this case, even though the function is in another module, it can read and modify the contents of the variable—it just cannot refer to it by name.

</p><p>It is also possible to use the <code>static</code> keyword on the definition of a local variable. Without the <code>static</code> keyword, the variable is automatically allocated when the function is called and released when the function exits (thus the name "automatic variable"). Its value is not retained between function calls. With the <code>static</code> keyword, the variable is allocated when the program starts and released when the program ends. Its value is not lost between function calls. The variable is still local, since it can only be accessed by name inside the function that defined it. But a reference (pointer) to it can be passed to another function, allowing it to read and modify the contents of the variable (again without referring to it by name).

</p><p>External variables are allocated and initialized when the program starts, and the memory is only released when the program ends. Their lifetime is the same as the program's.

</p><p>If the initialization is not done explicitly, external (static or not) and local static variables are initialized to zero. Local automatic variables are uninitialized, i.e. contain "trash" values.

</p><p>The <code>static</code> keyword applied to a function definition changes the linkage of the function so that it is only visible from the translation unit where its definition is located. This prevents the function from being called <i>by name</i> from outside its module (it remains possible to pass a <a href="Function_pointer" title="Function pointer">function pointer</a> out of the module and use that to invoke the function). Declaring a function using the <code>static</code> keyword is also a good way to keep its name short while avoiding name clashes.

</p>

<div class="mw-heading mw-heading2"><h2 id="Example_(C_programming_language)">Example (C programming language)</h2></div>

<p>File 1:

</p>

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre><span class="w"> </span><span class="c1">// Explicit definition, this actually allocates</span>

<span class="w"> </span><span class="c1">// as well as describing</span>

<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">global_variable</span><span class="p">;</span>

<span class="w"> </span><span class="c1">// Function prototype (declaration), assumes </span>

<span class="w"> </span><span class="c1">// defined elsewhere, normally from include file. </span>

<span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">some_function</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span><span class="w"> </span>

<span class="w"> </span><span class="n">global_variable</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>

<span class="w"> </span><span class="n">some_function</span><span class="p">();</span>

<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span>

</pre></div>

<p>File 2:

</p>

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre><span class="w"> </span><span class="c1">// Implicit declaration, this only describes and</span>

<span class="w"> </span><span class="c1">// assumes allocated elsewhere, normally from include</span>

<span class="w"> </span><span class="k">extern</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">global_variable</span><span class="p">;</span><span class="w"> </span>

<span class="w"> </span><span class="c1">// Function header (definition)</span>

<span class="w"> </span><span class="o">++</span><span class="n">global_variable</span><span class="p">;</span>

</pre></div>

<p>In this example, the variable Global_Variable is <i>defined</i> in File 1. In order to utilize the same variable in File 2, it must be <i>declared</i>. Regardless of the number of files, a global variable is only <i>defined</i> once; however, it must be <i>declared</i> in any file outside of the one containing the definition.

</p>

<p>If the program is in several source files, and a variable is defined in file1 and used in file2 and file3, then extern declarations are needed in file2 and file3 to connect the occurrences of the variable. The usual practice is to collect extern declarations of variables and functions in a separate file, historically called a header, that is included by #include at the front of each source file. The suffix .h is conventional for header names.

</p>

<p>The normal methodology is for allocation and actual definitions to go into .c files, but mere declarations and prototypes do not allocate and just describe the types and parameters so that the compiler can work correctly, and that information belongs in a .h header file that others can safely include without any possible conflict.

</p>

<ul><li><a href="Declaration_(computer_programming)" title="Declaration (computer programming)">Declaration</a> – Programming language construct specifying an identifier's properties</li>

<li><a href="Function_prototype" title="Function prototype">Function prototype</a> – Declaration of a function's name and type signature but not body</li>

<li><a href="Global_variable" title="Global variable">Global variable</a> – Computer programming, a variable accessible throughout a computer program</li>

<li><a href="Linker_(computing)" title="Linker (computing)">Linker (computing)</a> – Program that combines intermediate build files into an executable file</li>

<li><a href="Local_variable" title="Local variable">Local variable</a> – Computer programming, a variable only usable in a portion of a program (the scope)</li>

<li><a href="Scope_(computer_science)" title="Scope (computer science)">Scope</a> – Part of a computer program where a given name binding is valid</li>

<li><a href="Static_variable" title="Static variable">Static variable</a> – Programming variable that persists for the lifetime of the program</li>

<li><a href="The_C_Programming_Language" title="The C Programming Language"><i>The C Programming Language</i></a> – Book by Brian Kernighan and Dennis Ritchie</li></ul>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist">

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite id="CITEREFKernighan" class="citation book cs1">Kernighan, B. W. <i>A TUTORIAL INTRODUCTION TO THE LANGUAGE B</i>. Murray Hill, New Jersey: Bell Laboratories.</cite></span>

</li>

</ol></div></div>

<div class="mw-heading mw-heading2"><h2 id="External_links">External links</h2></div>

<ul><li><a rel="nofollow" class="external text" href="https://docs.microsoft.com/en-us/cpp/c-language/storage-class-specifiers-for-external-level-declarations">Microsoft C Language Reference: Storage-Class Specifiers for External-Level Declarations</a></li>

<li><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf">"The C Standard (C99 with Technical corrigenda TC1, TC2, and TC3 included)"</a> <span class="cs1-format">(PDF)</span>.</cite> <span style="font-size: 85%;">(3.61 <a href="Mebibyte" class="mw-redirect" title="Mebibyte">MiB</a>)</span>. In particular, see sections 6.2.2 (Linkage of identifiers), 6.2.4 (Storage duration of objects), 6.7.1 (Storage-class specifiers) and 6.9 (External definitions).</li></ul></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-03-24" href="https://en.wikipedia.org/wiki/?title=External_variable&oldid=1282175871">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>